// pages/promotion/index.ts
import {
  ARTICLE_TYPE_LIST,
  MAIN_TASK_TYPE_LIST,
  PUBLIC_ACCOUNT_LIST_BACK, PUBLIC_ACCOUNT_STATE_LIST,
  PUBLIC_ACCOUNT_STATUS_LIST,
} from "../../utils/enmu";
import {
  taskExecuteClipboard,
  taskExecutePage,
  taskExecuteRoute, taskExecuteShare,
  taskExecuteShareRead
} from "../../service/api/api-promotion";
import { fontSizeCalc, handleCode, handleErrCode, isWXMP, silentLogin } from "../../utils/util";

let toast;
Page({

  /**
   * 页面的初始数据
   */
  data: {
    searchText: "",// 搜索关键字
    currentTab: 0, // 当前选中的tab
    collapseIndex: 0, // 当前主任务展开的下标
    collapseSecIndex: 0, // 当前子任务展开的下标
    scrollTop: 0, // 滚动到顶部
    tabs: [
      { name: "进行中" },
      { name: "已结束" },
      { name: "已暂停" },
      // {name: "已完成"}
    ],// 筛选条件
    backTaskList: [],// 任务列表
    taskList: [],// 任务列表
    access: {} as any,// 当前用户权限
    currentUser: {},// 当前用户信息
    options: '',
    triggered: false,// 自定义下拉是否被触发 true 表示下拉刷新已经被触发，false 表示下拉刷新未被触发
    isWxmp: false,// 当前是否从公众号模板跳转过来的
    searchTimeout: null,
    current: 1,// 第几页
    pageSize: 20,// 每页多少条数据
    total: 0,// 总共有多少条

    tabFontSize: fontSizeCalc(28),
    overFontSize: fontSizeCalc(32),
    iconSize: fontSizeCalc(40),
    statusTagSize: fontSizeCalc(28) + 'rpx',
  },
  /**
   * 开始搜索
   * @param detail
   * @param showLoading
   * @param current 分页数据，
   */
  async searchFun({ detail = { value: '' }, showLoading = true, current = 1 }) {
    // 有传值的时候才把这个值设置进去
    let _that = this;
    let { pageSize, currentTab } = this.data;
    // if (_that.isEnd()){
    //     return
    // }
    _that.setData({
      current: current,
      searchText: detail.value
    })
    showLoading && wx.showLoading({
      title: '搜索中...'
    })
    // 执行搜索函数
    await taskExecutePage({
      current,
      pageSize,
      name: detail.value,
      run: currentTab + 1,
      channel: 1,
    }).then(async (response) => {
      _that.handleListData(response)
    }).catch(error => {
      console.warn(error)
      handleErrCode(error, 'none')
    }).finally(() => {
      _that.searchFinally()
    })
  },
  /**
   * 搜索取消
   */
  searchCancel() {
    this.setData({
      searchText: ""
    })

    this.searchFun({})
  },
  /**
   * 切换tab
   * @param detail
   */
  tabsChange({ detail = { index: 0 } }) {
    this.setData({
      currentTab: detail.index,
      scrollTop: 0,
      current: 1,
      total: 0,
      searchText: ""
    })

    this.searchFun({});// 开始搜索
    // 先做本地过滤
    // let currentTab = detail.index;
    // let {backTaskList} = this.data;
    //
    // let curList = backTaskList.filter(item =>{
    //     return detail.index + 1 === item.run
    // })
    // this.setData({
    //     taskList: curList,
    //     currentTab,
    //     scrollTop: 0,
    // })
  },

  /**
   * 处理一下文章类型
   * @param type
   */
  handleArticleType(type: Number) {
    return ARTICLE_TYPE_LIST.find(item => item.value === Number(type)) || {}
  },

  /**
   * 处理一下任务状态
   * @param type
   */
  handleMainTaskType(type: Number) {
    return MAIN_TASK_TYPE_LIST.find(item => item.value === Number(type)) || {}
  },

  /**
   * 处理一下公众号任务状态
   * @param task
   */
  handlePublicAccountTaskIndex(task: Object) {
    // 根据执行列表找到没执行的那一步，即值为0的下标，根据下标去找到对应状态列表的值
    let obj = {
      index: -1,
      times: 0,// 找了几次
    }
    obj.index = PUBLIC_ACCOUNT_STATUS_LIST.findIndex(item => {
      obj.times++;
      // @ts-ignore
      return task[item] !== 1
    })
    return obj
  },

  /**
   * 处理一下公众号任务状态
   * @param task
   */
  handlePublicAccountTaskTypeBack(task: Object) {
    const { index, times } = this.handlePublicAccountTaskIndex(task);
    let tarI = index;
    if (tarI === -1 && times >= 4) {// 没找到，并且是找了一圈，就是完成了
      tarI = 4;// 已完成
    }
    return PUBLIC_ACCOUNT_LIST_BACK.find(item => item.value === tarI) || {}
  },

  /**
   * 处理一下公众号任务状态
   * @param task
   */
  handlePublicAccountTaskType(task: Object) {
    // 过滤找一下当前还没完成的步骤
    return Array.from(PUBLIC_ACCOUNT_STATE_LIST).filter(item =>
      // @ts-ignore
      task[item.isKey] >= 1 && task[item.key] !== null && task[item.key] !== 1
    )
  },

  /**
   * 处理返回的列表值
   * @param res
   */
  handleListData(res: Object) {
    let dataList = [], total = this.data.total;
    if (res?.code === 0 && res?.data?.data) {
      const newData = res.data.data || [];
      dataList = Array.isArray(newData) && newData.map((item, index) => {
        // 子任务处理循环
        item.list = Array.isArray(item.tasks) && item.tasks.map((task, i) => {
          let stateList = [], isShowShare = false, isShowCopy = false, isShowLike = false;
          // 待阅读，待分享，待推广, 待点赞
          // const {isDemandReadTime, isDemandShare, isDemandShareRead, isDemandLike, isDemandClipboard} = task;
          // 先判断 isDemandShare, isDemandShareRead, isDemandLike, isDemandClipboard 等属性内容，
          // 在大于等于1的情况下采取判断界面待做的任务状态
          switch (task.type) {
            case 1: // 公众号，要阅读，要分享，要分享阅读，点赞
              if (this.handlePublicAccountTaskType(task) && this.handlePublicAccountTaskType(task).length < 1) {
                stateList.push({
                  key: 'executeRouter', label: '已完成', color: '#389E0D'
                })
              } else {
                stateList = this.handlePublicAccountTaskType(task);
              }
              break;
            case 2: // 视频号，只需要阅读
              if (task.executeRouter !== 1) {
                stateList.push({
                  key: 'executeRouter', label: '待完成', color: '#FF814A'
                })
              } else {
                stateList.push({
                  key: 'executeRouter', label: '已完成', color: '#389E0D'
                })
              }
              isShowCopy = false;
              break;
            case 3: // 抖音，只需复制
              if (task.executeClipboard !== 1) {
                stateList.push({
                  key: 'executeClipboard', label: '待复制', color: '#FF814A'
                })
              } else {
                stateList.push({
                  key: 'executeClipboard', label: '已复制', color: '#389E0D'
                })
              }
              isShowCopy = true;
              break;
            default:
              break;
          }
          const { label: typeName, icon } = this.handleArticleType(task.type)

          return {
            ...task,
            current: i,
            route: task.route ?? '',// 处理一下null和undefined
            typeName,// 文章类型
            stateList,// 状态列表
            // stateList: this.getStateList(stateList),// 状态列表
            isShowCopy,// 是否能复制
            icon: '/image/' + icon + '.png',// 图标类型
          }
        }) || []
        const { label: runText, color: bgColor, tagType, decoration } = this.handleMainTaskType(item.run);
        return {
          ...item,
          current: index,
          remarks: item.remarks ?? '',// 处理一下null和undefined
          bgColor,// 任务状态背景色
          tagType,// tag类型
          runText,// 当前总任务状态
          decoration,// 当前总任务状态
        }
      }) || [];
      total = res.data.total || 0
    } else {
      wx.showToast({
        title: res.msg || '查询失败',
        icon: 'error',
        duration: 2000
      })
    }
    const oldList = this.data.taskList
    if (this.data.current > 1) {// 上拉加载更多
      dataList = [...oldList, ...dataList]
    }
    this.setData({
      // backTaskList: dataList,
      taskList: dataList,
      total
    })
    // 主动触发一次
    // this.tabsChange({detail: {index: this.data.currentTab}}, true)
  },

  /**
   * 点击子任务事件
   */
  subTaskClick(e: Object) {
    const task = e.currentTarget.dataset.item || {};
    switch (task.type) {
      case 1:// 公众号，要执行阅读时长统计，页面跳转，分享，分享阅读四个步骤
        this.taskExecuteReadTimeFun(task)
        break;
      case 2:// 视频号，只需要执行页面跳转就好
        this.taskExecuteRouteFun(task)
        break;
      case 3:// 抖音，只要执行复制就好，这里啥也不干
        // this.copyString(task);
        break;
      default:
        this.taskExecuteReadTimeFun(task)
        break;
    }
  },
  /**
   * 执行公众号阅读
   */
  taskExecuteReadTimeFun(task) {
    wx.navigateTo({
      url: `/pages/publicDetail/index?task=${encodeURIComponent(JSON.stringify(task))}`,
      success: async function (res) {
        // 通过eventChannel向被打开页面传送数据
        // res.eventChannel.emit('acceptDataFromOpenerPage', {data: task});
        // await taskExecuteRoute({
        //     taskId: task.id,
        // }).then(res => {
        //     if (res?.code === 0) {
        //         // handleCode(res)
        //     }
        // }).catch(e => {
        //     console.warn(e);
        //     handleErrCode(e)
        // })
      }
    })
  },
  /**
   * 执行视频号跳转
   */
  // taskExecuteRouteFun(task) {
  //   const _that = this;
  //   wx.getSystemInfo({
  //     success: (res) => {
  //       // windows | mac为pc端
  //       // android | ios为手机端
  //       if (res.platform === 'ios' || res.platform === 'android') {// 安卓与ios
  //         _that.taskExecute(task)
  //       } else {
  //         handleErrCode('暂不支持该平台打开')
  //       }
  //     },
  //     fail: (err) => {
  //       console.warn(err);
  //       handleErrCode('打开失败')
  //     },
  //   });
  // },
  /**
  * 执行视频号跳转
  */
  taskExecuteRouteFun(task) {
    const _that = this;
    try {
      const systemInfo = wx.getDeviceInfo();
      // windows | mac为pc端
      // android | ios为手机端
      if (systemInfo.platform === 'ios' || systemInfo.platform === 'android' || systemInfo.system.toLowerCase().includes('harmonyos')) {
        _that.taskExecute(task);
      } else {
        handleErrCode("系统暂不支持");
      }
    } catch (err) {
      console.warn(err);
      handleErrCode('打开失败');
    }
  },
  /**
   * 真正执行的函数
   */
  taskExecute(task) {

    console.log('==this.data.taskList==', this.data.taskList);
    console.log('==task==', task);

    const _that = this;

    wx.openChannelsActivity({
      finderUserName: task.routeFinderUserName,
      feedId: task.routeFeedId,
      async success(res) {
        await taskExecuteRoute({
          taskId: task.id,
        }).then(res => {
          task.executeRouter = 1;
          _that.searchFun({ showLoading: false });
          if (res?.code !== 0) {
            handleCode(res)
          }
        }).catch(e => {
          console.warn(e);
          handleErrCode(e);
        })
      },
      fail(err) {
        const { errMsg, errCode } = err;
        errCode !== 5 && handleErrCode(errMsg || '打开失败')
      }
    })
  },

  /**
   * 执行抖音复制到剪切板
   */
  async taskExecuteClipboardFun(task) {
    await taskExecuteClipboard({
      taskId: task.id,
    }).then(res => {
      // wx.showToast({
      //     title: res.msg || '复制失败',
      //     icon: 'success',
      //     duration: 1500
      // })

      this.searchFun({ showLoading: false });

      taskExecuteRoute({
        taskId: task.id,
      }).then(res => {
        if (res?.code === 0) {
          // handleCode(res)
        }
      }).catch(e => {
        console.warn(e);
        // handleErrCode(e)
      })
    }).catch(e => {
      console.warn(e);
      wx.showToast({
        title: e || '复制失败',
        icon: 'error',
        duration: 1500
      })
    })
  },
  /**
   * 执行公众号分享
   */
  async taskExecuteShareFun(task) {
    await taskExecuteShare({
      taskId: task.id,
    }).then(res => {


      wx.showToast({
        title: res.msg || '分享失败',
        icon: 'success',
        duration: 1500
      })
    }).catch(e => {
      console.warn(e);
      handleErrCode(e);
    })
  },
  /**
   * 执行公众号分享
   */
  async taskExecuteShareReadFun(task) {
    await taskExecuteShareRead({
      taskId: task.id,
    }).then(res => {
      wx.showToast({
        title: res.msg || '分享阅读失败',
        icon: 'error',
        duration: 1500
      })
    }).catch(e => {
      console.warn(e);
      handleErrCode(e);
    })
  },
  /**
   * 复制字符串
   */
  copyString(e) {
    let _that = this;
    const task = e?.currentTarget?.dataset?.item || e;
    wx.setClipboardData({
      data: task.route || "",
      success(res) {
        wx.hideToast()
        wx.showToast({
          title: '链接已复制',
          icon: 'none',
          duration: 1500
        })
        if (task.executeClipboard === 1) {// 已完成就不要去执行调用接口了
          return
        }
        setTimeout(() => {
          _that.taskExecuteClipboardFun(task)
        }, 1500)
      },
      fail(err) {
        console.warn(err);
        wx.showToast({
          title: '复制失败',
          icon: 'error',
          duration: 1500
        })
      },
      // complete(){
      //     wx.hideToast()
      // }
    })
  },
  /**
   * 粘贴字符串
   */
  pasteString() {
    wx.getClipboardData({
      success(res) {
        wx.showToast({
          title: res || '空',
          icon: 'error',
          duration: 1500
        })
      },
      fail(err) {
        console.warn(err);
        wx.showToast({
          title: '粘贴失败',
          icon: 'error',
          duration: 1500
        })
      }
    })
  },

  /**
   * 分享
   */
  shareFun() {
  },

  /**
   * 列表滚动
   */
  viewScroll({ detail = { scrollLeft, scrollTop, scrollHeight, scrollWidth, deltaX, deltaY } }) {

  },

  /**
   * 获取任务状态列表
   */
  getStateList(stateList: Array) {
    return stateList.filter((item, index) => index === 0)
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    const isWxmp = isWXMP(options)
    this.setData({
      isWxmp,
      options: JSON.stringify(options)
    })
    if (isWxmp) {// 代表从公众号通知模板进来的，要去静默登录一下，登录有结果之后要记得赋值
      silentLogin(() => {
        this.getCountInfo();

        this.searchFun({});
      });
    } else {
      this.getCountInfo();
      this.searchFun({});
    }
    // 手动触发加载
    this.selectComponent('#noticeModal').fetchData();
  },

  /**
   * 提示语
   */
  showToast(title) {
    let params = {
      title,
    }
    toast && toast.show(params);
  },

  /**
   * 是否到底的判断
   */
  isEnd() {
    let { current, pageSize, total } = this.data;
    if (total && current !== 1 && current * pageSize >= total) {
      this.showToast('已经到底了')
      return true
    } else {
      return false
    }
  },

  /**
   * 获取账号信息
   */
  getCountInfo() {
    let { globalData: { access, currentUser } } = getApp();
    this.setData({
      access,
      currentUser,
    })
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {
    toast = this.selectComponent("#toast")
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // !this.data.isWxmp && this.tabsChange({ detail: { index: this.data.currentTab } });// 没有token采取获取
    wx.hideShareMenu({
      menus: ['shareAppMessage', 'shareTimeline'],// 隐藏分享到朋友和分享到朋友圈
      // menus: ['shareTimeline'],// 隐藏分享到朋友和分享到朋友圈
    })
    // wx.showShareMenu({
    //     withShareTicket: true,
    //     menus: [
    //         'shareAppMessage', // 分享给朋友
    //         'shareTimeline',// 分享到朋友圈
    //     ]
    // });
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * scroll-view 下拉刷新
   */
  refresherPulling() {
    this.setData({
      triggered: true
    })
  },

  /**
   * 刷新函数
   */
  refreshFun(e: object, current = 1) {
    // 标题栏显示刷新图标，转圈圈
    wx.showNavigationBarLoading()

    this.searchFun({ current });
    clearTimeout(this.data.searchTimeout);
    let searchTimeout = setTimeout(() => {
      this.searchFinally()
    }, 2000);
    this.setData({
      searchTimeout,
    })
  },

  /**
   * 下拉加载更多数据函数
   */
  scrollToLowerFun() {
    if (this.isEnd()) {
      return
    }
    // 调用刷新函数
    this.refreshFun({}, this.data.current + 1)
  },

  /**
   * 搜索最终
   */
  searchFinally() {
    clearTimeout(this.data.searchTimeout)
    // 标题栏隐藏刷新转圈圈图标
    wx.hideNavigationBarLoading();
    wx.stopPullDownRefresh();
    wx.hideLoading();
    this.setData({
      triggered: false
    })
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },
})